





//声明函数  创建一个 count 个 value 的数组
// function createArray(count: number, value: any): any[]{
//   //声明一个数组
//   let arr: any[] = [];
//   //循环
//   for(let i=0;i<count;i++){
//     arr.push(value);
//   }
//   //返回
//   return arr;
// }

//测试
// let arr = createArray(10, 'iloveyou');
// console.log(arr);
//这里没有方法提示
// console.log(arr[0].slice(1, 5));
//报错, ts 同样没有报错
// console.log(arr[0].toFixed(2));

//泛型的使用   T 泛型变量, 名字可以随便, 常用的名字  T  P  V  R
function createArray<T>(count: number, value: T): T[]{
  //声明一个数组
  let arr: T[] = [];
  //循环
  for(let i=0;i<count;i++){
    arr.push(value);
  }
  //返回
  return arr;
}

//调用
let arr = createArray<string>(10, 'iloveyou');
//这里有提示
console.log(arr[0].slice(1, 5));
//这里有报错提示
// console.log(arr[0].toFixed(2));

//多个泛型参数                       元组
// function test<T, V>(v1: T, v2: V): [T, V]{
//   return [v1, v2];
// }

// let res = test<string, number>('出入相友，守望相助', 1619420236);

// console.log(res[0].slice(0, 2));

//声明用户的接口
interface User{
  id: number,
  name: string,
  age: number,
}

//声明书籍的接口
interface Book{
  id: number,
  title: string,
  price: number
}

//泛型接口
interface Res<T>{
  status: number,
  headers: object,
  data: T
}

//声明一个对象
let res : Res<User>  = {
  status: 200, 
  headers: {},
  data: {
    id: 1,
    name:'重阳',
    age: 20
  }
}

let res2 : Res<Book> = {
  status: 200, 
  headers: {},
  data: {
    id: 1,
    title:'三国演义',
    price: 29.9
  }
}


//-------------------------------------
interface Res2<T>{
  status: number, 
  headers: object,
  data: {
    code: string,
    msg: string,
    data: T
  }
}

let res22: Res2<Book> = {
  status: 200, 
  headers: {},
  data: {
    code: '0000',
    msg: 'OK',
    data: {
      id: 1,
      title: '三国演义',
      price: 20
    }
  }
}

//------------------------------------
interface Res3<T>{
  status: number, 
  headers: object,
  data: T
}

//响应体的结果
interface ResponseData<T>{
  code: string,
  msg: string,
  data: T
}

let res33: Res3<ResponseData<Book>> = {
  status: 200, 
  headers: {},
  data: {
    code: '0000',
    msg: 'OK',
    data: {
      id: 1,
      title: '三国演义',
      price: 20
    }
  }
}
// --------------------------
class Container<T>{
  //属性
  store: T[]
  //构造方法   形参:  T[]  参数类型
  constructor(v: T[]){
    this.store = v;
  }
}

//实例化
let numArr = new Container<number>([1,2,3,4]); 
//存的数字
// console.log(numArr.store[0].toFixed(1));
//存书籍
let books = new Container<Book>([{id: 1, title: 'xxx', price: 20}])
books.store.push({id: 2, title: '西游记', price: 15.9})
console.log(books);


//----------------------------------------------
interface LengthWish{
  length: number
}
//泛型约束  
function fn<T extends LengthWish>(arg: T){
  console.log(arg.length);
}

let arr2: number[] = [1,2,3]
// ts 此时并没有提示
fn<number[]>(arr2)


export {};